 ▄▄▄·▄▄▄         ▐▄▄▄▄▄▄ . ▄▄· ▄▄▄▄▄    .▄▄ · ▄ •▄ ▄▄▄ .▄▄▌  ▄▄▄ .▄▄▄▄▄       ▐ ▄ 
▐█ ▄█▀▄ █·▪       ·██▀▄.▀·▐█ ▌▪•██      ▐█ ▀. █▌▄▌▪▀▄.▀·██•  ▀▄.▀·•██  ▪     •█▌▐█
 ██▀·▐▀▀▄  ▄█▀▄ ▪▄ ██▐▀▀▪▄██ ▄▄ ▐█.▪    ▄▀▀▀█▄▐▀▀▄·▐▀▀▪▄██▪  ▐▀▀▪▄ ▐█.▪ ▄█▀▄ ▐█▐▐▌
▐█▪·•▐█•█▌▐█▌.▐▌▐▌▐█▌▐█▄▄▌▐███▌ ▐█▌·    ▐█▄▪▐█▐█.█▌▐█▄▄▌▐█▌▐▌▐█▄▄▌ ▐█▌·▐█▌.▐▌██▐█▌
.▀   .▀  ▀ ▀█▄▀▪ ▀▀▀• ▀▀▀ ·▀▀▀  ▀▀▀      ▀▀▀▀ ·▀  ▀ ▀▀▀ .▀▀▀  ▀▀▀  ▀▀▀  ▀█▄▀▪▀▀ █▪
							           ______
							        .-"      "-.
							       /            \
							      |              |
							      |,  .-.  .-.  ,|
							      | )(__/  \__)( |
							      |/     /\     \|
							      (_     ^^     _)
							       \__|IIIIII|__/
							        | \IIIIII/ |
							        \          /
							         `--------`
//-------------------------------------------------------------------------------------//
The intended use of this project file is to have a quick jumping-off point when
starting a new game.

BEFORE YOU EDIT ANYTHING, ENSURE YOU SAVE THE PROJECT FILE AS SOMETHING ELSE
//--------------------------------------------------------------------------------------//

This guide will explain the purpose of every resource. Just ctrl+f [resourcename] with square brackets.


   _____  _____ _____  _____ _____ _______ _____ 
  / ____|/ ____|  __ \|_   _|  __ \__   __/ ____|
 | (___ | |    | |__) | | | | |__) | | | | (___  
  \___ \| |    |  _  /  | | |  ___/  | |  \___ \ 
  ____) | |____| | \ \ _| |_| |      | |  ____) |
 |_____/ \_____|_|  \_\_____|_|      |_| |_____/ 
 

[isInView]
-no arguments
//-------------//
Will return TRUE if any portion of the object's collision mask is still within camera view 0. 
If the entire collision mask is outside of the view, it will return FALSE.

***
EX: if (!isInView){
		instance_destroy();
	}
***
>If the object goes outside the view, it will be destroyed
.
.
[animation_ended]
-image_index (what current frame of the sprite is being shown, note that 0 counts as the first frame)
-image_number (full amount of frames in the sprite being shown, note that this does not count 0 as the first frame, so it's subtracted by one in the script)
//-------------//
Used to check for when an animation ends. Generally it's expected to just put the built-in "image_index" and "image_number" into argument 0 and 1 respectively.
But if there are substitutes being used for the built-in sprite variables (such as with an object drawing multiple sprites) it's recommended to put whatever 
variable you have assigned to the image index in argument 0, and to put whatever the sprite index is into function "sprite_get_number()" 
which will return the number of frames for the given sprite.

***
EX: if (animation_ended(image_index,image_number)){
			image_speed = 0;
			image_index = image_number-1;
	}
	
EX 2: if (animation_ended(spt_img[0],sprite_get_number(spt_sprite[0])){
			spt_imgspd[0] = 0;
			spt_img[0] = sprite_get_number(spt_sprite[0])-1;
		}
***
>Once the animations ends, stop on the last frame
.
.
[approach]
-var (this is the variable you wish to alter)
-target (this is the number you want to move the variable to, or stop from exceeding)
-amount (this is the amount you want to increment the variable each time this function is called)
//-------------//
Used to move a variable towards a given target value, and to stop it from exceeding that target value.
This works in both to directions. So we can move 5 to 10, or 5 to -5, either one will work.

***
EX: timer = approach(timer,0,1);
***
>decrease timer by 1, will not go below 0.
.
.
[screenshake]
-amount (how many pixels we're going to move the screen in any random direction)
-time (how long the screenshake will last)
//-------------//
Applies a screenshake effect, really only changes some variables in oCamera, the actual moving of the camera is in the End Step of that object.
The amount of pixels shaking decreases as the duration of the shake goes.

***
EX: screenshake(8,30);
***
>Shakes the screen by 8 pixels for 30 frames.
.
.
[scr_wave]
-from (value 1 to oscillate between)
-to (value 2 to oscillate between)
-duration (speed at which the wave goes, in seconds. inputting 1 would be one second)
-offset (optional offset of where the wave "starts"
//-------------//
Returns a value between "from" and "to" over "duration". 

***
EX: y = scr_wave(ystart-10,ystart+10,2,0);
***
>Moves the y position between -10 and 10 from the starting y position
.
.
[wrap]
-value (value to wrap around)
-min (minimum allowed value)
-max (maximum allowed value)
//-------------//
Wraps a value around a given minimum and maximum value

***
EX: x++
	x = wrap(x,0,room_width);
***
>X coordinate continuously moves forward by 1 pixel, if it exceeds the room width it'll wrap back around to zero
.
.
[get_diameter_of_ellipse]
-width(width of the ellipse)
-height(height of the ellipse)
-angle(angle from the center of the ellipse to pull diameter from)
//-------------//
Gets the length from the center of an ellipse to the edge, depending on the angle that is being checked

***
EX: var angle = 180;
	var dist = get_diameter_of_ellipse(100,50,angle);
	pointX = x + lengthdir_x(dist, angle),
	pointY = y + lengthdir_y(dist, angle),
***
>pointX and pointY will give the edge of a 100x50 ellipse
.
.
[numeric_spring]
-value (actual value that we are altering)
-veloc (speed at which the value is changing, this needs to be a variable with changes being recorded every step)
-target val (value that we are trying to "spring" to)
-damping ratio (how quickly the springing slows down, think of it like adding rigidness to a spring, 0 = springs forever, 1 = doesn't spring at all
-ang freq (how many times the value oscillates per second)
-time step (how much of a second each step/use of the script takes)
//-------------//
REQUIRES A NON-LOCAL VARIABLE FOR VELOCITY TO WORK!
Brings a value towards a target value, but makes said value "oscillate" back and forth, like a spring. 
Best way to think of it is like the "approach" script, but springy.
It returns an array, one for velocity and one for the change in value.

***
EX: var _s = numeric_spring(image_yscale,velocity_yscale,target_yscale,0.2,3,1);

	image_yscale = _s[num_spr.value];
	velocity_yscale = _s[num_spr.velocity];
***
>Brings the image_yscale towards whatever the target_yscale is, average damping, oscillating 3 times per second at normal speed
>It is important to note that "velocity_yscale" is not a local variable
>It is also important to note that "num_spr.value" is an enumerator that is declared when the game starts in the "enums" script
.
.
[scr_collision]
-no arguments
//-------------//
REQUIRES hsp VARIABLE AND vsp AND oSolid TO WORK!
Moves object by whatever value is input into hsp and vsp, when the collision mask of the object is about to collide into oSolid,
the object moves by 1 pixel until it is right next to the solid object.

***
EX: hsp = 8;
	vsp = 0;
	scr_collision();
	if (hsp == 0){
		show_debug_message("hit a wall");
	}
***
>Moves forward by 8 pixels, if a horizontal collision occurs, the console will show message "hit a wall"
.
.
[scr_collision_slope]
-no arguments
//-------------//
REQUIRES hsp, vsp, AND maxSpeed VARIABLES TO WORK!
Moves object by whatever value is input into hsp and vsp, when the collision mask fo the object is about to collide into oSolid,
the object moves by 1 pixel until it is right next to the solid object, with a vertical movement allowance up to whatever the "maxSpeed" variable is set to.
While this script's intent is to be used for walking up and down shallow slopes, it also works as a sort of "ledge forgiveness" collision as well.
***
EX: hsp = 8;
	vsp = 0;
	scr_collision_slope();
***
>Moves forward on a slope
.
.
[scr_gravity]
-vsp 
-jumpSpeed (or whatever you want to set this number to, this is the max falling speed)
-grav (or whatever you want to set this number to, how powerful gravity is, 0.5 is usually a good number for it)
//-------------//
REQUIRES vsp AND RUNNING scr_collision TO WORK!
Applies gravity to the vertical speed of an object. Extremely simple code that I really just made cuz 
it's easier for my brain when doing platformers.
***
EX: var _jumpSpeed = 8, _grav = 0.5;
	scr_gravity(vsp,_jumpSpeed,_grav);
	scr_collision();
***
>adds 0.5 to the vsp every frame, when when in midair the object will fall
.
.
[solid_failsafe]
-no arguments
//-------------//
REQUIRES oSolid TO WORK!
If at any point the object's collision mask is overlapping with oSolid collision mask,
This script sends a point out in all 8 directions and checks for collision, the first point to return no collision
Is where we will place our object the next frame.
Ideal use is on objects where getting stuck in a solid object would result in a softlock.
***
EX: scr_collision();
	solid_failsafe();
***
>We run our normal collision code, which puts us flush up against solid objects, then afterwards, solid failsafe checks if for any reason we are actually colliding with oSolid and rectifies it.
>Note that the script, when running, is very costly. This should not be used alone as a collision checker, only as a failsafe.
.
.
[gamepad_lastbutton]
-device number
//-------------//
Works like "keyboard_lastkey" in that it returns the most recent input, but for the gamepad.
If the last input was nothing, return 0.
***
EX: if (gamepad_lastbutton(0)!=0) {
		jump_button = gamepad_lastbutton(0);
	}
***
>If an input has been made, set "jump_button" to the last gamepad input
.
.
[gamepad_name]
-button id
//-------------//
Returns a string which has the name for whatever button id is plugged in.
***
EX: draw_text(x,y,"Press "+gamepad_name(jump_button)+" to jump!");
***
>Draws text showing the button for jumping
>If the button for jumping was A/Cross for example, it'd say "Press A/Cross to jump!"
.
.
[gamepad_image]
-button id
//-------------//
REQUIRES sGamePadButton TO WORK! ENSURE THAT IF YOU MAKE YOUR OWN SPRITE FOR THE GAMEPAD
BUTTONS THAT THE FRAMES ARE THE SAME AS THE ONE IN THE PLACEHOLDER!
Returns an image that reflects what button id is plugged in.
***
EX: draw_sprite(sGamePadButton,gamepad_image(gp_face1),x,y);
***
>Draws a sprite showing the buttom-most face button (A/Cross or gp_face1)
.
.
[keyboard_name]
-key id
//-------------//
Returns a string which has the name for whatever key id is plugged in.
***
EX: draw_text(x,y,"Press "+keyboard_name(jump_button)+" to jump!");
***
>Draws text showing the key for jumping
>If the for jumping was Z for example, it'd say "Press Z to jump!"
.
.
[gamepad_anykey]
-no arguments
//-------------//
Returns device number of gamepad if any button on it is pressed.
Will return -1 if no gamepad has any buttons pressed.
***
EX: var _anykey = gamepad_anykey();
	if (_anykey != -1){
		gamepad_device = _anykey();
	}
***
>Sets "gamepad_device" variable to whatever device number has last been pressed, if any.
.
.
[create_menu_page]









